package com.ruoyi.ManagerApi.service.impl;

import java.io.File;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import com.dahuatech.hutool.http.Method;
import com.dahuatech.icc.oauth.model.v202010.GeneralResponse;
import com.dahuatech.icc.oauth.model.v202010.OauthConfigUserPwdInfo;
import com.dahuatech.icc.oauth.utils.HttpUtils;
import com.hikvision.artemis.sdk.ArtemisHttpUtil;
import com.hikvision.artemis.sdk.config.ArtemisConfig;
import com.ruoyi.ManagerApi.vo.GetDataVo;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.datascope.annotation.DataScope;
import org.springframework.http.MediaType;
import com.alibaba.fastjson.JSON;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.ruoyi.ManagerApi.domain.TTpApiSet;
import com.ruoyi.ManagerApi.domain.TTpManufacturer;
import com.ruoyi.ManagerApi.mapper.TTpApiSetMapper;
import com.ruoyi.ManagerApi.mapper.TTpManufacturerMapper;
import com.ruoyi.common.core.utils.DateUtils;
import com.ruoyi.common.core.web.domain.AjaxResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import com.ruoyi.ManagerApi.mapper.TTpApiMapper;
import com.ruoyi.ManagerApi.domain.TTpApi;
import com.ruoyi.ManagerApi.service.ITTpApiService;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;

import static com.ruoyi.common.security.utils.SecurityUtils.getLoginUser;

/**
 * 接口管理接口信息Service业务层处理
 *
 * @author li
 * @date 2025-09-12
 */
@Service
public class TTpApiServiceImpl implements ITTpApiService {
    @Autowired
    private TTpApiMapper tTpApiMapper;
    @Autowired
    private TTpManufacturerMapper tTpManufacturerMapper;
    @Autowired
    private TTpApiSetMapper tTpApiSetMapper;
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 查询接口管理接口信息
     *
     * @param id 接口管理接口信息主键
     * @return 接口管理接口信息
     */
    @Override
    public TTpApi selectTTpApiById(String id) {
        return tTpApiMapper.selectTTpApiById(id);
    }

    /**
     * 查询接口管理接口信息列表
     *
     * @param tTpApi 接口管理接口信息
     * @return 接口管理接口信息
     */
    @Override
    @DataScope(deptAlias = "m")
    public List<TTpApi> selectTTpApiList(TTpApi tTpApi) {
        return tTpApiMapper.selectTTpApiList(tTpApi);
    }

    /**
     * 新增接口管理接口信息
     *
     * @param tTpApi 接口管理接口信息
     * @return 结果
     */
    @Override
    @Transactional
    public int insertTTpApi(TTpApi tTpApi) {
        tTpApi.setCreateBy(getLoginUser().getUsername());
        tTpApi.setCreateTime(DateUtils.getNowDate());
        //同时需要新增接口厂家对应的apiconut数量
        TTpManufacturer tTpManufacturer = tTpManufacturerMapper.selectTTpManufacturerById(String.valueOf(tTpApi.getTtpMid()));
        tTpManufacturer.setApiCount(tTpManufacturer.getApiCount() + 1);
        //更新数量
        tTpManufacturerMapper.updateTTpManufacturer(tTpManufacturer);
        return tTpApiMapper.insertTTpApi(tTpApi);
    }

    /**
     * 修改接口管理接口信息
     *
     * @param tTpApi 接口管理接口信息
     * @return 结果
     */
    @Override
    public int updateTTpApi(TTpApi tTpApi) {
        tTpApi.setUpdateBy(getLoginUser().getUsername());
        tTpApi.setUpdateTime(DateUtils.getNowDate());
        return tTpApiMapper.updateTTpApi(tTpApi);
    }

    /**
     * 批量删除接口管理接口信息
     *
     * @param ids 需要删除的接口管理接口信息主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteTTpApiByIds(String[] ids) {
        for (String id : ids) {
            //根据id查询信息
            TTpApi tTpApi = tTpApiMapper.selectTTpApiById(id);
            //同时需要新增接口厂家对应的apiconut数量
            TTpManufacturer tTpManufacturer = tTpManufacturerMapper.selectTTpManufacturerById(String.valueOf(tTpApi.getTtpMid()));
            tTpManufacturer.setApiCount(tTpManufacturer.getApiCount() - 1);
            if (tTpManufacturer.getApiCount() < 0) tTpManufacturer.setApiCount(0L);
            //更新数量
            tTpManufacturerMapper.updateTTpManufacturer(tTpManufacturer);
        }
        return tTpApiMapper.deleteTTpApiByIds(ids);
    }

    /**
     * 删除接口管理接口信息信息
     *
     * @param id 接口管理接口信息主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteTTpApiById(String id) {
        //根据id查询信息
        TTpApi tTpApi = tTpApiMapper.selectTTpApiById(id);
        //同时需要新增接口厂家对应的apiconut数量
        TTpManufacturer tTpManufacturer = tTpManufacturerMapper.selectTTpManufacturerById(String.valueOf(tTpApi.getTtpMid()));
        tTpManufacturer.setApiCount(tTpManufacturer.getApiCount() - 1);
        if (tTpManufacturer.getApiCount() < 0) tTpManufacturer.setApiCount(0L);
        //更新数量
        tTpManufacturerMapper.updateTTpManufacturer(tTpManufacturer);
        return tTpApiMapper.deleteTTpApiById(id);
    }

    @Override
    public String selectTTpApiByPathId(GetDataVo getDataVo) {
        try {
            // 1. 获取接口配置
            TTpApi api = tTpApiMapper.selectTTpApiById(String.valueOf(getDataVo.getPathId()));
            if (api == null) {
                throw new ServiceException("接口不存在");
//                return AjaxResult.error("接口不存在");
            }
            // 2. 获取厂家信息
            TTpManufacturer manufacturer = tTpManufacturerMapper.selectTTpManufacturerById(String.valueOf(api.getTtpMid()));
            if (manufacturer == null) {
                throw new ServiceException("厂家不存在");
//                return AjaxResult.error("厂家不存在");
            }
            //2.1如果厂家的路径填的为mysql时,直接就使用mysql查询语句执行数据库然后返回结果
            if ("mysql".equals(manufacturer.getTokenUrl())) {
                //使用mysql语句直接查询
                return jdbcTemplate.queryForList(getDataVo.getParameters()).toString();
//                return AjaxResult.success(jdbcTemplate.queryForList(getDataVo.getParameters()));
            }
            // 3. 获取接口详细配置
            TTpApiSet apiSet = tTpApiSetMapper.selectApiSetByApiType(String.valueOf(api.getId()));
            if (apiSet == null) {
                throw new ServiceException("接口配置不存在");
//                return AjaxResult.error("接口配置不存在");
            }
            //3.1如果厂家的路径填的为HIK时,使用海康sdk请求查询数据
            if ((manufacturer.getTokenUrl() != null && manufacturer.getTokenUrl().contains("HIK"))) {
                //使用海康专属接口请求,如果是post或者get使用不同的请求
                JSONObject tokenJson = JSON.parseObject(manufacturer.getTokenJson());
                String appKey = tokenJson.getString("appkey");
                String secret = tokenJson.getString("secret");
                String ip = tokenJson.getString("ip");
                int port = tokenJson.getIntValue("port");
                // 构建ArtemisConfig
                ArtemisConfig config = new ArtemisConfig();
                config.setHost(ip + ":" + port);
                config.setAppKey(appKey);
                config.setAppSecret(secret);
                final String getCamsApi = api.getUrlPath();
                String body="";
                //三元表达式如果getDataVo.getParameters()存在，否则用apiSet.getParameter()
                if (getDataVo.getParameters()!=null){
                    body = JSON.toJSON(getDataVo.getParameters()).toString();
                }else {
                    body = JSON.toJSON(apiSet.getParameter()).toString();
                }
                Map<String, String> path = new HashMap<String, String>(2) {
                    {
                        put("https://", getCamsApi);
                    }
                };
                if (Objects.equals(apiSet.getMethod(), "POST")) {
                    String response  = ArtemisHttpUtil.doPostStringArtemis(config, path, body, null, null, "application/json");
                    return JSON.parse(response).toString();
                } else if (Objects.equals(apiSet.getMethod(), "GET")) {
                    String response  = ArtemisHttpUtil.doGetArtemis(config, path, null, null, null);
                    return JSON.parse(response).toString();
                }
            }
            //3.2如果厂家的路径填的为DAHUA时,使用大华sdk请求查询数据
            if ((manufacturer.getTokenUrl() != null && manufacturer.getTokenUrl().contains("DAHUA"))) {
                //使用大华专属接口请求,如果是post或者get使用不同的请求
                JSONObject tokenJson = JSON.parseObject(manufacturer.getTokenJson());
                String host = tokenJson.getString("host");
                String clientId =  tokenJson.getString("clientId");
                String clientSecret =  tokenJson.getString("clientSecret");
                String userName =  tokenJson.getString("userName");
                String password =  tokenJson.getString("password");
                String port = tokenJson.getString("port");
                boolean isHttp = Boolean.parseBoolean(tokenJson.getString("isHttp"));//是否使用http，http需运维中心开启http调试模式支持，开启后端口固定是83
                OauthConfigUserPwdInfo oauthConfig = new OauthConfigUserPwdInfo(host, clientId, clientSecret, userName, password, isHttp, port);
                oauthConfig.getHttpConfigInfo().setReadTimeout(-1l);//设置读取超时时间，单位毫秒，默认-1
                oauthConfig.getHttpConfigInfo().setConnectionTimeout(-1l);//设置连接超时，单位毫秒，默认-1
                //设置请求体
                Map body = new HashMap<>();
                body.put("key", "value");
                //设置请求头
                Map header = new HashMap<>();
                header.put("key", "value");
                //执行请求
                if (Objects.equals(apiSet.getMethod(), "POST")) {
                    GeneralResponse response = HttpUtils.executeJson(api.getUrlPath(), body, header, Method.POST, oauthConfig, GeneralResponse.class);
                    return JSON.parse(String.valueOf(response)).toString();
                } else if (Objects.equals(apiSet.getMethod(), "GET")) {
                    //执行请求
                    GeneralResponse response = HttpUtils.executeForm(api.getUrlPath(), null,null, Method.GET, oauthConfig,GeneralResponse.class);
                    return JSON.parse(String.valueOf(response)).toString();
                }else if (Objects.equals(apiSet.getMethod(), "POST")&&manufacturer.getRestType().equals("multipart/form-data")){
                    //todo 待实现认证接口中前端输入resttype字段实现multipart/form-data文件上传下载
                    //设置请求体
                    String filePath = "文件路径";
                    //请求参数为文件
                    File file = new File(filePath);
                    body.put("file",file);
                    //执行请求
                    GeneralResponse response = HttpUtils.executeForm(api.getUrlPath(), body, header, Method.POST , oauthConfig, GeneralResponse.class);
                    return JSON.parse(String.valueOf(response)).toString();
                }
            }
            // 4. 获取访问令牌（如果需要）
            String accessToken = null;
            if (manufacturer.getIfCheck() == 0 && StringUtils.isNotEmpty(manufacturer.getTokenUrl()) && !"0".equals(manufacturer.getTokenJson())) {
                accessToken = getAccessToken(manufacturer);
            }
            // 5. 构建请求
            HttpHeaders headers = buildHeaders(manufacturer, api, accessToken);
            HttpMethod httpMethod = HttpMethod.valueOf(apiSet.getMethod().toUpperCase());
            // 6. 构建URL和请求体
            String fullUrl = buildFullUrl(manufacturer, api, apiSet, getDataVo.getParameters(), httpMethod);
            String requestBody = "";
            if (httpMethod != HttpMethod.GET) {
                requestBody = buildRequestBody(apiSet, getDataVo.getParameters());
            }
            // 7. 创建请求实体
            HttpEntity<String> requestEntity = new HttpEntity<>(requestBody, headers);
            // 8. 发送请求
            ResponseEntity<String> response = restTemplate.exchange(fullUrl, httpMethod, requestEntity, String.class);
            // 9. 处理响应
            return processResponse(response, apiSet);
        } catch (Exception e) {
            throw new ServiceException("调用接口失败");
//            return AjaxResult.error("调用接口失败: " + e.getMessage());
        }

    }

    @Override
    public String selectTTpApiApiStateByPathId(String id) {
        try {
            // 1. 获取接口配置
            TTpApi api = tTpApiMapper.selectTTpApiById(id);
            if (api == null) {
                throw new ServiceException("接口不存在");
//                return AjaxResult.error("接口不存在");
            }
            // 2. 获取厂家信息
            TTpManufacturer manufacturer = tTpManufacturerMapper.selectTTpManufacturerById(String.valueOf(api.getTtpMid()));
            if (manufacturer == null) {
                throw new ServiceException("厂家不存在");
//                return AjaxResult.error("厂家不存在");
            }
            // 3. 获取接口详细配置
            TTpApiSet apiSet = tTpApiSetMapper.selectApiSetByApiType(String.valueOf(api.getId()));
            if (apiSet == null) {
                throw new ServiceException("接口配置不存在");
//                return AjaxResult.error("接口配置不存在");
            }
            //3.1如果厂家的路径填的为mysql时,直接就使用mysql查询语句执行数据库然后返回结果
            if ("mysql".equals(manufacturer.getTokenUrl())) {
                //使用mysql语句直接查询
                return String.valueOf(jdbcTemplate.queryForList(apiSet.getParameter()));
            }
            //3.2如果厂家的路径填的为mysql时,直接就使用mysql查询语句执行数据库然后返回结果
            if ((manufacturer.getTokenUrl() != null && manufacturer.getTokenUrl().contains("HIK"))) {
                //使用海康专属接口请求,如果是post或者get使用不同的请求
                // 解析 token_json 中的配置
                JSONObject tokenJson = JSON.parseObject(manufacturer.getTokenJson());
                String appKey = tokenJson.getString("appkey");
                String secret = tokenJson.getString("secret");
                String ip = tokenJson.getString("ip");
                int port = tokenJson.getIntValue("port");
                // 构建ArtemisConfig
                ArtemisConfig config = new ArtemisConfig();
                config.setHost(ip + ":" + port);
                config.setAppKey(appKey);
                config.setAppSecret(secret);
                final String getCamsApi = manufacturer.getApiUrl();
                String body = JSON.toJSON(apiSet.getParameter()).toString();
                Map<String, String> path = new HashMap<String, String>(2) {
                    {
                        put("https://", getCamsApi);
                    }
                };
                if (Objects.equals(apiSet.getMethod(), "POST")) {
                    return String.valueOf(JSON.parse(ArtemisHttpUtil.doPostStringArtemis(config, path, body, null, null, "application/json")));
                } else if (Objects.equals(apiSet.getMethod(), "GET")) {
                    return String.valueOf(JSON.parse(ArtemisHttpUtil.doGetArtemis(config, path, null, null, null)));
                }
            }

            // 4. 获取访问令牌（如果需要）
            String accessToken = null;
            if (manufacturer.getIfCheck() == 0 && StringUtils.isNotEmpty(manufacturer.getTokenUrl()) && !"0".equals(manufacturer.getTokenJson())) {
                accessToken = getAccessToken(manufacturer);
            }
            // 5. 构建请求
            HttpHeaders headers = buildHeaders(manufacturer, api, accessToken);
            HttpMethod httpMethod = HttpMethod.valueOf(apiSet.getMethod().toUpperCase());
            // 6. 构建URL和请求体
            String fullUrl = buildFullUrl(manufacturer, api, apiSet, "", httpMethod);
            String requestBody = "";
            if (httpMethod != HttpMethod.GET) {
                requestBody = buildRequestBody(apiSet, "");
            }
            // 7. 创建请求实体
            HttpEntity<String> requestEntity = new HttpEntity<>(requestBody, headers);
            // 8. 发送请求
            ResponseEntity<String> response = restTemplate.exchange(fullUrl, httpMethod, requestEntity, String.class);

            // 6. 检查响应
            if (response.getStatusCode().is2xxSuccessful()) {
                //如果连接成功，同时修改state字段为正常
                TTpApi tTpApi = new TTpApi();
                tTpApi.setId(Long.valueOf(id));
                tTpApi.setState(1L);
                tTpApiMapper.updateTTpApi(tTpApi);
            }
            // 9. 处理响应
            return processResponse(response, apiSet);
        } catch (Exception e) {
            //如果连接失败，同时修改state字段为不通
            TTpApi tTpApi = new TTpApi();
            tTpApi.setId(Long.valueOf(id));
            tTpApi.setState(0L);
            tTpApiMapper.updateTTpApi(tTpApi);
            throw new ServiceException("调用接口失败");
//            return AjaxResult.error("调用接口失败: " + e.getMessage());
        }
    }

    private String buildRequestBody(TTpApiSet apiSet, String parameters) {
        //如果parameters不等于空，则修改apiSet的参数
        if (StringUtils.isNotEmpty(parameters) && !"0".equals(apiSet.getParameter()) && !"".equals(apiSet.getParameter())) {
            apiSet.setParameter(parameters);
        }
        //如果apiSet.setParameter存在进行循环放入请求体中
        JSONObject requestBody = StringUtils.isEmpty(apiSet.getParameter()) ? new JSONObject() : JSON.parseObject(apiSet.getParameter());
        for (String key : requestBody.keySet()) {
            Object value = requestBody.get(key);
            if (value instanceof String) {
                requestBody.put(key, value);
            }
        }
        return requestBody.toJSONString();
    }

    private String buildFullUrl(TTpManufacturer manufacturer, TTpApi api, TTpApiSet apiSet, String parameters, HttpMethod httpMethod) {
        // 1. 获取基础URL
        String baseUrl;
        if (StringUtils.isNotEmpty(apiSet.getApiUrl())) {
            baseUrl = apiSet.getApiUrl();
        } else if (StringUtils.isNotEmpty(api.getUrlPath())) {
            baseUrl = manufacturer.getApiUrl() + api.getUrlPath();
        } else {
            baseUrl = manufacturer.getApiUrl();
        }
        // 2. 如果是GET请求，将参数添加到URL中
        if (httpMethod == HttpMethod.GET) {
            try {
                // 解析前端传递的参数字符串为JSONObject
                JSONObject paramsJson = StringUtils.isEmpty(parameters) ? new JSONObject() : JSON.parseObject(parameters);
                // 构建查询字符串
                StringBuilder queryString = new StringBuilder();
                for (String key : paramsJson.keySet()) {
                    Object value = paramsJson.get(key);
                    if (queryString.length() > 0) {
                        queryString.append("&");
                    }
                    queryString.append(URLEncoder.encode(key, "UTF-8")).append("=").append(URLEncoder.encode(value.toString(), "UTF-8"));
                }
                // 添加到URL
                if (queryString.length() > 0) {
                    if (baseUrl.contains("?")) {
                        baseUrl += "&" + queryString.toString();
                    } else {
                        baseUrl += "?" + queryString.toString();
                    }
                }
            } catch (Exception e) {
                System.err.println("构建查询字符串失败: " + e.getMessage());
            }
        }
        return baseUrl;
    }

    private HttpHeaders buildHeaders(TTpManufacturer manufacturer, TTpApi api, String accessToken) {
        HttpHeaders headers = new HttpHeaders();
        // 1. 添加厂家固定头
        if (StringUtils.isNotEmpty(manufacturer.getHeaders()) && !manufacturer.getHeaders().equals("0")) {
            JSONObject headerJson = JSON.parseObject(manufacturer.getHeaders());
            for (String key : headerJson.keySet()) {
                headers.add(key, headerJson.getString(key));
            }
        }
        // 2. 添加接口特定头
        if (StringUtils.isNotEmpty(api.getHeaders()) && !api.getHeaders().equals("0")) {
            JSONObject apiHeaderJson = JSON.parseObject(api.getHeaders());
            for (String key : apiHeaderJson.keySet()) {
                headers.add(key, apiHeaderJson.getString(key));
            }
        }
        // 3. 添加认证头
        if (accessToken != null && StringUtils.isNotEmpty(manufacturer.getHeaderName()) && !manufacturer.getHeaderName().equals("0")) {
            headers.add(manufacturer.getHeaderName(), accessToken);
        }
        // 4. 设置内容类型
        if (StringUtils.isNotEmpty(manufacturer.getRestType()) && !manufacturer.getRestType().equals("0")) {
            headers.setContentType(MediaType.valueOf(manufacturer.getRestType()));
        } else {
            headers.setContentType(MediaType.APPLICATION_JSON);
        }
        return headers;
    }

    private String getAccessToken(TTpManufacturer manufacturer) {
        try {
            // 1. 检查必要参数
            if (StringUtils.isEmpty(manufacturer.getTokenUrl())) {
                System.err.println("Token URL 未配置");
                return null;
            }
            // 2. 解析 map_dat 配置
            String tokenFieldName = "token"; // 默认字段名
            if (StringUtils.isNotEmpty(manufacturer.getMapDat())) {
                try {
                    JSONObject mapDatJson = JSON.parseObject(manufacturer.getMapDat());
                    if (mapDatJson.containsKey("name")) {
                        tokenFieldName = mapDatJson.getString("name");
                    }
                } catch (Exception e) {
                    System.err.println("解析 map_dat 配置失败: " + e.getMessage());
                }
            }
            // 3. 构建请求头
            HttpHeaders headers = new HttpHeaders();
            if (StringUtils.isNotEmpty(manufacturer.getHeaders()) && !"0".equals(manufacturer.getHeaders())) {
                JSONObject headerJson = JSON.parseObject(manufacturer.getHeaders());
                for (String key : headerJson.keySet()) {
                    headers.add(key, headerJson.getString(key));
                }
            } else {
                headers.setContentType(MediaType.APPLICATION_JSON);
            }
            // 4. 构建请求体
            String requestBody = "{}";
            if (StringUtils.isNotEmpty(manufacturer.getTokenJson()) && !"0".equals(manufacturer.getTokenJson())) {
                requestBody = manufacturer.getTokenJson();
            }
            // 5. 设置请求方法
            HttpMethod httpMethod = HttpMethod.POST; // 默认使用 POST
            if (StringUtils.isNotEmpty(manufacturer.getMethod())) {
                try {
                    httpMethod = HttpMethod.valueOf(manufacturer.getMethod().toUpperCase());
                } catch (Exception e) {
                    System.err.println("不支持的请求方法: " + manufacturer.getMethod() + ", 使用默认 POST");
                }
            }
            // 6. 创建请求实体
            HttpEntity<String> requestEntity = new HttpEntity<>(requestBody, headers);
            // 7. 发送请求
            ResponseEntity<String> response = restTemplate.exchange(manufacturer.getApiUrl() + manufacturer.getTokenUrl(), httpMethod, requestEntity, String.class);
            // 8. 检查响应状态
            if (!response.getStatusCode().is2xxSuccessful()) {
                System.err.println("获取Token失败，状态码: " + response.getStatusCodeValue());
                return null;
            }
            JSONObject json = JSON.parseObject(response.getBody());
            // 3. 检查是否包含 Token 字段
            if (json.containsKey(tokenFieldName)) {
                String token = json.getString(tokenFieldName);
                return token;
            }
            // 9. 解析Token
            return response.getBody();
        } catch (Exception e) {
            System.err.println("获取Token异常: " + e.getMessage());
            return null;
        }
    }


    private String processResponse(ResponseEntity<String> response, TTpApiSet apiSet) {
        if (response.getStatusCode().is2xxSuccessful()) {
            String responseBody = response.getBody();
            // 如果配置了返回结构解析
            if (StringUtils.isNotEmpty(apiSet.getTpField())) {
                try {
                    JSONObject json = JSON.parseObject(responseBody);
                    JSONObject result = new JSONObject();
                    // 解析映射规则
                    JSONObject fieldMapping = JSON.parseObject(apiSet.getTpField());
                    for (String key : fieldMapping.keySet()) {
                        String jsonPath = fieldMapping.getString(key);
                        Object value = getValueByJsonPath(json, jsonPath);
                        result.put(key, value);
                    }
                    return String.valueOf(result);
                } catch (Exception e) {
                    throw new ServiceException("解析响应失败");
//                    return AjaxResult.error("解析响应失败: " + e.getMessage());
                }
            }
            // 直接返回原始响应
//            return AjaxResult.success(responseBody);
            return responseBody;
        }
        throw new ServiceException("接口调用失败，状态码");
//        return AjaxResult.error("接口调用失败，状态码: " + response.getStatusCodeValue());
    }

    private Object getValueByJsonPath(JSONObject json, String jsonPath) {
        // 简化实现，实际可以使用 JSONPath 库
        String[] path = jsonPath.split("\\.");
        JSONObject current = json;
        for (int i = 0; i < path.length - 1; i++) {
            current = current.getJSONObject(path[i]);
        }
        return current.get(path[path.length - 1]);
    }

}
